home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / collections / SortField.as < prev    next >
Encoding:
Text File  |  2008-05-21  |  11.1 KB  |  412 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.system.ApplicationDomain;
  6.    import mx.collections.errors.SortError;
  7.    import mx.core.mx_internal;
  8.    import mx.resources.ResourceBundle;
  9.    import mx.utils.ObjectUtil;
  10.    import mx.utils.StringUtil;
  11.    
  12.    use namespace mx_internal;
  13.    
  14.    public class SortField extends EventDispatcher
  15.    {
  16.       private static var resourceNoComparatorSortField:String;
  17.       
  18.       mx_internal static const VERSION:String = "2.0.1.0";
  19.       
  20.       private static var packageResources:ResourceBundle = ResourceBundle.getResourceBundle("collections",ApplicationDomain.currentDomain);
  21.       
  22.       loadResources();
  23.       
  24.       private var _caseInsensitive:Boolean;
  25.       
  26.       private var _compareFunction:Function;
  27.       
  28.       private var _numeric:Boolean;
  29.       
  30.       private var _descending:Boolean;
  31.       
  32.       private var _usingCustomCompareFunction:Boolean;
  33.       
  34.       private var _name:String;
  35.       
  36.       public function SortField(param1:String = null, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false)
  37.       {
  38.          super();
  39.          _name = param1;
  40.          _caseInsensitive = param2;
  41.          _descending = param3;
  42.          _numeric = param4;
  43.          _compareFunction = stringCompare;
  44.       }
  45.       
  46.       private static function loadResources() : void
  47.       {
  48.          resourceNoComparatorSortField = packageResources.getString("noComparatorSortField");
  49.       }
  50.       
  51.       [Bindable("caseInsensitiveChanged")]
  52.       public function get caseInsensitive() : Boolean
  53.       {
  54.          return _caseInsensitive;
  55.       }
  56.       
  57.       public function set caseInsensitive(param1:Boolean) : void
  58.       {
  59.          if(param1 != _caseInsensitive)
  60.          {
  61.             _caseInsensitive = param1;
  62.             dispatchEvent(new Event("caseInsensitiveChanged"));
  63.          }
  64.       }
  65.       
  66.       [Bindable("nameChanged")]
  67.       public function get name() : String
  68.       {
  69.          return _name;
  70.       }
  71.       
  72.       public function set name(param1:String) : void
  73.       {
  74.          _name = param1;
  75.          dispatchEvent(new Event("nameChanged"));
  76.       }
  77.       
  78.       mx_internal function get usingCustomCompareFunction() : Boolean
  79.       {
  80.          return _usingCustomCompareFunction;
  81.       }
  82.       
  83.       private function numericCompare(param1:Object, param2:Object) : int
  84.       {
  85.          var fa:Number = NaN;
  86.          var fb:Number = NaN;
  87.          var a:Object = param1;
  88.          var b:Object = param2;
  89.          try
  90.          {
  91.             fa = _name == null ? Number(a) : Number(a[_name]);
  92.          }
  93.          catch(error:Error)
  94.          {
  95.          }
  96.          try
  97.          {
  98.             fb = _name == null ? Number(b) : Number(b[_name]);
  99.          }
  100.          catch(error:Error)
  101.          {
  102.          }
  103.          return ObjectUtil.numericCompare(fa,fb);
  104.       }
  105.       
  106.       public function set numeric(param1:Boolean) : void
  107.       {
  108.          if(_numeric != param1)
  109.          {
  110.             _numeric = param1;
  111.             dispatchEvent(new Event("numericChanged"));
  112.          }
  113.       }
  114.       
  115.       private function stringCompare(param1:Object, param2:Object) : int
  116.       {
  117.          var fa:String = null;
  118.          var fb:String = null;
  119.          var a:Object = param1;
  120.          var b:Object = param2;
  121.          try
  122.          {
  123.             fa = _name == null ? String(a) : String(a[_name]);
  124.          }
  125.          catch(error:Error)
  126.          {
  127.          }
  128.          try
  129.          {
  130.             fb = _name == null ? String(b) : String(b[_name]);
  131.          }
  132.          catch(error:Error)
  133.          {
  134.          }
  135.          return ObjectUtil.stringCompare(fa,fb,_caseInsensitive);
  136.       }
  137.       
  138.       public function get compareFunction() : Function
  139.       {
  140.          return _compareFunction;
  141.       }
  142.       
  143.       [Bindable("numericChanged")]
  144.       public function get numeric() : Boolean
  145.       {
  146.          return _numeric;
  147.       }
  148.       
  149.       mx_internal function internalCompare(param1:Object, param2:Object) : int
  150.       {
  151.          var _loc3_:int = 0;
  152.          _loc3_ = compareFunction(param1,param2);
  153.          if(descending)
  154.          {
  155.             _loc3_ *= -1;
  156.          }
  157.          return _loc3_;
  158.       }
  159.       
  160.       public function reverse() : void
  161.       {
  162.          descending = !descending;
  163.       }
  164.       
  165.       override public function toString() : String
  166.       {
  167.          return ObjectUtil.toString(this);
  168.       }
  169.       
  170.       mx_internal function getArraySortOnOptions() : int
  171.       {
  172.          var _loc1_:* = 0;
  173.          if(mx_internal::usingCustomCompareFunction || name == null || _compareFunction == xmlCompare || _compareFunction == dateCompare)
  174.          {
  175.             return -1;
  176.          }
  177.          _loc1_ = 0;
  178.          if(caseInsensitive)
  179.          {
  180.             _loc1_ |= Array.CASEINSENSITIVE;
  181.          }
  182.          if(descending)
  183.          {
  184.             _loc1_ |= Array.DESCENDING;
  185.          }
  186.          if(numeric || _compareFunction == numericCompare)
  187.          {
  188.             _loc1_ |= Array.NUMERIC;
  189.          }
  190.          return _loc1_;
  191.       }
  192.       
  193.       private function dateCompare(param1:Object, param2:Object) : int
  194.       {
  195.          var fa:Date = null;
  196.          var fb:Date = null;
  197.          var a:Object = param1;
  198.          var b:Object = param2;
  199.          try
  200.          {
  201.             fa = _name == null ? a as Date : a[_name] as Date;
  202.          }
  203.          catch(error:Error)
  204.          {
  205.          }
  206.          try
  207.          {
  208.             fb = _name == null ? b as Date : b[_name] as Date;
  209.          }
  210.          catch(error:Error)
  211.          {
  212.          }
  213.          return ObjectUtil.dateCompare(fa,fb);
  214.       }
  215.       
  216.       public function set descending(param1:Boolean) : void
  217.       {
  218.          if(_descending != param1)
  219.          {
  220.             _descending = param1;
  221.             dispatchEvent(new Event("descendingChanged"));
  222.          }
  223.       }
  224.       
  225.       private function xmlCompare(param1:Object, param2:Object) : int
  226.       {
  227.          var sa:String = null;
  228.          var sb:String = null;
  229.          var a:Object = param1;
  230.          var b:Object = param2;
  231.          try
  232.          {
  233.             sa = _name == null ? a.toString() : a[_name].toString();
  234.          }
  235.          catch(error:Error)
  236.          {
  237.          }
  238.          try
  239.          {
  240.             sb = _name == null ? b.toString() : b[_name].toString();
  241.          }
  242.          catch(error:Error)
  243.          {
  244.          }
  245.          if(numeric)
  246.          {
  247.             return ObjectUtil.numericCompare(parseFloat(sa),parseFloat(sb));
  248.          }
  249.          return ObjectUtil.stringCompare(sa,sb,_caseInsensitive);
  250.       }
  251.       
  252.       mx_internal function initCompare(param1:Object) : void
  253.       {
  254.          var value:Object = null;
  255.          var typ:String = null;
  256.          var test:String = null;
  257.          var obj:Object = param1;
  258.          if(!mx_internal::usingCustomCompareFunction)
  259.          {
  260.             if(numeric)
  261.             {
  262.                _compareFunction = numericCompare;
  263.             }
  264.             else if(caseInsensitive)
  265.             {
  266.                _compareFunction = stringCompare;
  267.             }
  268.             else
  269.             {
  270.                if(_name)
  271.                {
  272.                   try
  273.                   {
  274.                      value = obj[_name];
  275.                   }
  276.                   catch(error:Error)
  277.                   {
  278.                   }
  279.                }
  280.                if(value == null)
  281.                {
  282.                   value = obj;
  283.                }
  284.                typ = typeof value;
  285.                switch(typ)
  286.                {
  287.                   case "string":
  288.                      _compareFunction = stringCompare;
  289.                      break;
  290.                   case "object":
  291.                      if(value is Date)
  292.                      {
  293.                         _compareFunction = dateCompare;
  294.                      }
  295.                      else
  296.                      {
  297.                         _compareFunction = stringCompare;
  298.                         try
  299.                         {
  300.                            test = value.toString();
  301.                         }
  302.                         catch(error2:Error)
  303.                         {
  304.                         }
  305.                         if(!test || test == "[object Object]")
  306.                         {
  307.                            _compareFunction = nullCompare;
  308.                         }
  309.                      }
  310.                      break;
  311.                   case "xml":
  312.                      _compareFunction = xmlCompare;
  313.                      break;
  314.                   case "boolean":
  315.                   case "number":
  316.                      _compareFunction = numericCompare;
  317.                }
  318.             }
  319.          }
  320.       }
  321.       
  322.       private function nullCompare(param1:Object, param2:Object) : int
  323.       {
  324.          var value:Object = null;
  325.          var left:Object = null;
  326.          var right:Object = null;
  327.          var found:Boolean = false;
  328.          var typeLeft:String = null;
  329.          var typeRight:String = null;
  330.          var a:Object = param1;
  331.          var b:Object = param2;
  332.          found = false;
  333.          if(a == null && b == null)
  334.          {
  335.             return 0;
  336.          }
  337.          if(_name)
  338.          {
  339.             try
  340.             {
  341.                left = a[_name];
  342.             }
  343.             catch(error:Error)
  344.             {
  345.             }
  346.             try
  347.             {
  348.                right = b[_name];
  349.             }
  350.             catch(error:Error)
  351.             {
  352.             }
  353.          }
  354.          if(left == null && right == null)
  355.          {
  356.             return 0;
  357.          }
  358.          if(left == null)
  359.          {
  360.             left = a;
  361.          }
  362.          if(right == null)
  363.          {
  364.             right = b;
  365.          }
  366.          typeLeft = typeof left;
  367.          typeRight = typeof right;
  368.          if(typeLeft == "string" || typeRight == "string")
  369.          {
  370.             found = true;
  371.             _compareFunction = stringCompare;
  372.          }
  373.          else if(typeLeft == "object" || typeRight == "object")
  374.          {
  375.             if(typeLeft is Date || typeRight is Date)
  376.             {
  377.                found = true;
  378.                _compareFunction = dateCompare;
  379.             }
  380.          }
  381.          else if(typeLeft == "xml" || typeRight == "xml")
  382.          {
  383.             found = true;
  384.             _compareFunction = xmlCompare;
  385.          }
  386.          else if(typeLeft == "number" || typeRight == "number" || typeLeft == "boolean" || typeRight == "boolean")
  387.          {
  388.             found = true;
  389.             _compareFunction = numericCompare;
  390.          }
  391.          if(found)
  392.          {
  393.             return _compareFunction(left,right);
  394.          }
  395.          throw new SortError(StringUtil.substitute(resourceNoComparatorSortField,name));
  396.       }
  397.       
  398.       [Bindable("descendingChanged")]
  399.       public function get descending() : Boolean
  400.       {
  401.          return _descending;
  402.       }
  403.       
  404.       public function set compareFunction(param1:Function) : void
  405.       {
  406.          _compareFunction = param1;
  407.          _usingCustomCompareFunction = param1 != null;
  408.       }
  409.    }
  410. }
  411.  
  412.